#include "StdAfx.h"
#include "ListaD.h"


ListaD::ListaD(void)
{
	cabeza=NULL;
}


ListaD::~ListaD(void)
{
}


void ListaD::setCabeza(NodoD* cabeza){
	this->cabeza = cabeza;
}

NodoD* ListaD::getCabeza(){
	return this->cabeza;
}

bool ListaD::estaVacia(){
	return cabeza == NULL;e
}
void ListaD::insertarInicio(DataPack* bf){

	NodoD* nuevo = new NodoD(bf);
	if (estaVacia()){
		cabeza= nuevo;
	}
	else{
		nuevo->setSig(cabeza);
		
		// SE ENLAZA HACIA ATRAS LA CABEZA PARA UNIRLA AL NUEVO ELEMENTO
		cabeza->setAnt(nuevo);

		cabeza = nuevo;
	}
}


void ListaD::insertarEnPosicion(int posicion, DataPack* bf){
	//supone 1<=posicion <=cantidad+1
	if (posicion ==1)
		insertarInicio(bf);
	else{
		NodoD* nuevo = new NodoD(bf);
		
		if (posicion== largoLista() +1){   // para que quede de ultimo..
			NodoD* aux = localiza(posicion-1);
			nuevo->setAnt( aux);
			aux->setSig(nuevo);
		}
		else{
			NodoD* aux = localiza(posicion);
			nuevo->setSig( aux );
			nuevo->setAnt( aux->getAnt() );
			aux->getAnt()->setSig ( nuevo );
			aux->setAnt( nuevo );
		}
	}
}


int ListaD::largoLista(){

	int contador=0;
	for (NodoD* aux = cabeza; aux !=NULL;  aux=aux->getSig())
		contador++;
	return contador;
}

char* ListaD::muestraLista(){
	char respuesta [200]="";
	NodoD* aux = cabeza;
	while (aux!=NULL){
		strcat(respuesta, aux->getDataPack()->getPeso());
		strcat(respuesta, "\n");
		strcat(respuesta, aux->getDataPack()->getTiempo());
		strcat(respuesta, "\n");
		aux = aux->getSig();
	}
	return respuesta;
}

NodoD* ListaD::localiza(int pos){
	NodoD *aux = cabeza;
	int c=1;
	while(aux!=NULL){
		if (c == pos)
			return aux;
		else{
			aux= aux->getSig();
			c++;
		}
	}
}


void ListaD::eliminar(int pos){
	NodoD* aux = NULL;
	if (pos==1){
		aux = cabeza;
		cabeza=cabeza->getSig ();
		cabeza->setAnt(NULL);
	}
	else{
		aux =localiza(pos); 
		if (pos < largoLista()){
			aux->getAnt()->setSig(  aux->getSig() );
			aux->getSig()->setAnt( aux->getAnt());
		}
		else{  // posicion es el ultimo
			aux->getAnt()->setSig(NULL);
		}
	}
	delete aux;
}


void ListaD::invertir(){
	NodoD* auxFijo =cabeza;
	while(auxFijo->getSig()!=NULL){
		NodoD * aux2=auxFijo->getSig();
		// se aisla el nodo a mover
		auxFijo->setSig(aux2->getSig());
		if(aux2->getSig()!=NULL)
			aux2->getSig()->setAnt(auxFijo);

		//se reacomodan los enlaces
		aux2->setSig(cabeza);

		cabeza->setAnt(aux2);
		aux2->setAnt(NULL);
		cabeza=aux2;
	}
}

void ListaD::shellSortTiempo(){
	int gap=(this->largoLista())/2;
	int LLista = (this->largoLista());
	while(gap >= 1){
		int posInicio=1;
		int iterador=1;
		while((posInicio+gap)<=LLista){
		   iterador=1;
		   while((iterador+gap)<=LLista){	
			   NodoD* NodoA = this->localiza(iterador);
	 		   NodoD* NodoX = this->localiza(iterador+gap);
			   DataPack* b1 = NodoA->getDataPack();
			   DataPack* b2 =NodoX->getDataPack();
			   if(b1->getTiempo()>b2->getTiempo()){
				   NodoA->setDataPack(b2);
				   NodoX->setDataPack(b1);
			   }
			   iterador=iterador+gap;
		   }
		   posInicio=posInicio+1;
		}
	//Volver a calcular el gap
    gap= gap/2;
	}
}

void ListaD::shellSortPeso()
{
int gap=(this->largoLista())/2;
	int LLista = (this->largoLista());
	while(gap >= 1){
		int posInicio=1;
		int iterador=1;
		while((posInicio+gap)<=LLista){
		   iterador=1;
		   while((iterador+gap)<=LLista){	
			   NodoD* NodoA = this->localiza(iterador);
	 		   NodoD* NodoX = this->localiza(iterador+gap);
			   DataPack* b1 = NodoA->getDataPack();
			   DataPack* b2 =NodoX->getDataPack();
			   if(b1->getPeso()>b2->getPeso()){
				   NodoA->setDataPack(b2);
				   NodoX->setDataPack(b1);
			   }
			   iterador=iterador+gap;
		   }
		   posInicio=posInicio+1;
		}
	//Volver a calcular el gap
    gap= gap/2;
	}
}

void ListaD::generaDatos( int cantidad){
	int arr[] = {5,8,11,26,28};
	for (int i = 1; i<5; i++){
		this->insertarEnPosicion(i, new DataPack(arr[i-1]));
	}
	/*for (int i = 1; i<=cantidad; i++){
		int numero = rand()%1000+1;
		this->insertarEnPosicion(i, new DataPack(numero));
	}*/
}
